import org.w3c.dom.ls.LSOutput;

class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(this.name +" is eating");

    }



}
class Dog extends Animal{


    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark(){
        System.out.println(this.name+" 汪汪叫");
    }
    @Override
    public void eat(){
        System.out.println(this.name+"正在吃狗粮");
        //方法的重写（覆盖，复写）
        /*
        1,方法名相同
        2，方法的参数列表相同
        3，方法的返回值相同
        必须发生向上转型，且通过父类引用调用了父类与子类同名的方法重写
        * */
    }

}
class Bird extends Animal{
    public Bird(String name, int age) {
        super(name, age);
    }

    public void qiqi(){
        System.out.println(this.name+" 吱吱叫");
    }

    @Override//注解，修饰该方法，该方法是被重写的
    //作用：帮你最重写进行检查
    public void eat() {
        System.out.println(this.name+"正在吃鸟粮");
        //静态方法不能重写
        //被provide修饰，不能重写
        //被final修饰不能重写
        //子类的权限要大于等于父类的权限
        //重写的返回值是父子关系
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }

}
public class Text3 {
    public static void main(String[] args) {
        //向下转型
        Animal animal1 = new Dog("小黄",12);
        if (animal1 instanceof Bird){//如果animal1 引用 Bird
            Bird bird=(Bird) animal1;
            bird.fly();
        }
        else {
            System.out.println("animal1 instanceof Bird not");
        }

    }
    public static void main4(String[] args) {
        Animal animal1 = new Dog("小黄",12);
        //Dog dog=animal1;//报错，把大范围给到了一个小范围
        Dog dog=(Dog)animal1;
        dog.bark();

        Animal animal2 = new Dog("小黄",12);
        Bird bird=(Bird) animal2;//类型转换异常
        bird.fly();

    }
    public static void func(Animal animal1){
        animal1.eat();//当animal引用的对象不同，调用eat的表现行为不一样，这就称为多态
    }
    public static void main3(String[] args) {
        Dog dog=new Dog("小黄",12);
        Bird bird=new Bird("小小鸟",10);
        func(dog);
        func(bird);

    }















public static void func1(Animal animal1){
    //方法传参
}
    public static Animal func2(){
    return new Dog("小黄",12);
    //返回值
    }

public static void main2(String[] args) {//发生向上转型的时机

    Animal animal1 = new Dog("小黄",12);//直接赋值

    func1(new Dog("小黄",12));


}
    //    Dog dog=new Dog();
    //    Animal animal=dog;
public static void main1(String[] args) {
    Animal animal1 = new Dog("小黄",12);//向上转型
    animal1.eat();
    //animal1.bark();报错，animal1只能访问animal类中特有的
    //通过父类引用，只能访问父类自己特有的

}

;

}
